순환 구조

작성자

익명

작성일

2026.07.28

조회수

버전

순환 구조 (Recurrent Structure)

1. 개요

순환 구조(Recurrent Structure)란 신경망의 은닉층(Hidden Layer)에서 생성된 출력이 다시 자기 자신 혹은 이전 층의 입력으로 되돌아오는 연결 구조를 가진 신경망 형태를 의미한다.

일반적인 피드포워드(Feed-forward) 신경망은 입력층에서 출력층 방향으로 정보가 한 방향으로만 흐르며, 각 입력 데이터가 독립적으로 처리된다. 반면, 순환 구조는 내부의 루프(Loop)를 통해 과거의 정보를 기억하는 '상태(State)'를 유지함으로써, 데이터의 순서가 중요한 순차적 데이터(Sequential Data)를 처리하는 데 최적화되어 있다.

2. 동작 원리 및 구조

순환 구조의 핵심은 현재 시점($t$)의 출력값이 다음 시점($t+1$)의 입력값과 함께 연산에 사용된다는 점이다.

2.1 재귀적 메커니즘

시점 $t$에서의 은닉 상태 $h_t$는 다음과 같은 수식으로 정의된다. $$h_t = \phi(W_h h_{t-1} + W_x x_t + b)$$ - $x_t$: 현재 시점의 입력 벡터 - $h_{t-1}$: 이전 시점의 은닉 상태 (과거의 기억) - $W_h, W_x$: 가중치 행렬 - $\phi$: 활성화 함수. 기본 RNN에서는 $\tanh$가 표준적으로 사용된다. $\text{ReLU}$를 사용할 수도 있으나, 이 경우 값이 계속 누적되어 기울기 폭주(Exploding Gradient)가 발생할 위험이 있다.

2.2 시간축으로 펼치기 (Unrolling)

순환 구조는 개념적으로 루프 형태를 띠지만, 실제 연산과 학습을 위해 시간축으로 펼쳐서(Unrolling) 생각한다.

[Unrolling 개념 다이어그램]

(Folded Form)             (Unrolled Form)
     ↺                        h_0    h_1    h_2    h_3
   [RNN]  --->  (Time)  ---> [RNN] -> [RNN] -> [RNN] -> [RNN]
     ↑                         ↑        ↑        ↑        ↑
     x_t                      x_0      x_1      x_2      x_3

이는 동일한 가중치를 공유하는 여러 개의 층이 시간 순서대로 나열된 구조와 동일하며, 이를 통해 시퀀스 데이터의 각 요소가 순차적으로 처리됨을 시각화할 수 있다.

3. BPTT (Backpropagation Through Time)

순환 신경망의 학습은 BPTT(시간 기반 오차 역전파) 알고리즘을 통해 이루어진다.

BPTT는 일반적인 역전파(Backpropagation)를 시간축으로 확장한 개념이다. 출력층에서 발생한 오차(Loss)를 현재 시점에서 시작하여 과거 시점으로 거슬러 올라가며 각 시점의 가중치를 업데이트한다. 이때 모든 시점에서 동일한 가중치 행렬($W$)을 공유하므로, 각 시점에서 계산된 기울기(Gradient)의 합을 통해 최종 가중치를 갱신한다. 다만, 이 과정에서 기울기가 너무 커지는 기울기 폭주(Exploding Gradient) 현상이 발생할 수 있으며, 이를 해결하기 위해 Gradient Clipping 기법이 사용된다.

4. 주요 모델 및 발전 과정

4.1 기본 RNN의 한계: Vanishing Gradient

기본 RNN은 시퀀스가 길어질수록 앞부분의 정보가 뒤로 전달되지 않는 장기 의존성(Long-Term Dependency) 문제에 직면한다. 이는 기울기 소실(Vanishing Gradient) 현상 때문이다.

수학적 원리: BPTT 과정에서 $t$ 시점의 오차를 $k$ 시점 이전의 가중치로 미분할 때, 체인 룰(Chain Rule)에 의해 가중치 행렬 $W$의 거듭제곱 형태가 나타난다. $$\frac{\partial L_t}{\partial W} \propto \prod_{i=k+1}^{t} \frac{\partial h_i}{\partial h_{i-1}}$$ 만약 가중치 $W$의 고윳값(Eigenvalue)이 1보다 작다면, 시퀀스 길이가 길어질수록 기울기가 기하급수적으로 감소하여 0에 수렴하게 된다. 결과적으로 초기 입력 정보가 가중치 업데이트에 반영되지 않아 학습이 이루어지지 않는다.

4.2 LSTM과 GRU

이 문제를 해결하기 위해 '게이트(Gate)'라는 구조를 도입하여 정보의 흐름을 제어하는 모델들이 등장했다.

LSTM (Long Short-Term Memory): 셀 상태(Cell State)를 도입하고 입력, 망각, 출력 게이트를 통해 어떤 정보를 유지하고 버릴지 결정한다.
GRU (Gated Recurrent Unit): LSTM을 간소화한 모델로, 업데이트 게이트와 리셋 게이트만을 사용하여 연산 효율성을 높였다.

4.3 모델 특성 비교

(기준: 동일한 hidden size 설정 시)

구분	RNN	LSTM	GRU
구조	단순 루프	3개 게이트 + Cell State	2개 게이트
장기 의존성	취약 (기울기 소실)	강함	강함
연산 속도	매우 빠름	느림	보통
파라미터 수	적음	많음	중간

5. 주요 활용 분야 및 구조 분류

5.1 데이터 흐름에 따른 구조 분류

순환 구조는 입력과 출력의 개수에 따라 다음과 같이 분류된다.

구조	입력 $\rightarrow$ 출력	대표 사례
One-to-Many	단일 입력 $\rightarrow$ 시퀀스 출력	이미지 캡셔닝 (이미지 $\rightarrow$ 설명 문장)
Many-to-One	시퀀스 입력 $\rightarrow$ 단일 출력	감성 분석 (문장 $\rightarrow$ 긍정/부정)
Many-to-Many	시퀀스 입력 $\rightarrow$ 시퀀스 출력	기계 번역 (한국어 문장 $\rightarrow$ 영어 문장)

5.2 실제 적용 사례

시계열 데이터 예측: 주가 예측, 날씨 변화 분석, 전력 수요 예측.
자연어 처리(NLP): 텍스트 생성, 챗봇, 문법 교정.
음성 인식: 음성 신호(Waveform)를 텍스트로 변환.

6. 구현 예시 (PyTorch)

다음은 PyTorch를 사용하여 간단한 RNN 모델을 구축하고 검증하는 코드이다.

import torch
import torch.nn as nn

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleRNN, self).__init__()
        self.hidden_size = hidden_size
        # RNN 레이어 정의: batch_first=True는 입력 텐서의 첫 번째 차원을 배치 크기로 설정함
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        # 최종 출력을 위한 선형 레이어
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # h0: 초기 은닉 상태 (batch_size, num_layers, hidden_size)로 0으로 초기화
        h0 = torch.zeros(1, x.size(0), self.hidden_size).to(x.device)
        
        # out: 모든 시점의 은닉 상태, hn: 마지막 시점의 은닉 상태
        out, hn = self.rnn(x, h0)
        
        # 마지막 시점의 출력값만 사용하여 결과 예측 (Many-to-One 구조)
        # out[:, -1, :] -> (batch_size, hidden_size)
        out = self.fc(out[:, -1, :])
        return out

# 1. 하이퍼파라미터 설정
input_size = 10  # 입력 벡터 차원 (feature)
hidden_size = 20 # 은닉 상태 차원
output_size = 1  # 출력 차원

# 2. 모델 인스턴스 생성
model = SimpleRNN(input_size, hidden_size, output_size)
print("--- Model Structure ---")
print(model)

# 3. 더미 입력 데이터를 통한 검증
# 입력 형태: (batch_size, sequence_length, input_size)
test_input = torch.randn(32, 5, 10) 
with torch.no_grad():
    output = model(test_input)

print("\n--- Test Result ---")
print(f"Input Shape: {test_input.shape}")   # [32, 5, 10]
print(f"Output Shape: {output.shape}")     # [32, 1]

7. 한계 및 최신 동향

순환 구조는 순차적 데이터 처리에 혁신을 가져왔으나, 다음과 같은 근본적인 한계가 존재한다.

병렬 연산 불가: $t$ 시점의 연산을 위해 $t-1$ 시점의 결과가 반드시 필요하므로, GPU를 활용한 대규모 병렬 처리가 어렵고 학습 속도가 느리다.
완전한 장기 의존성 해결 불가: LSTM/GRU가 개선을 이루었으나, 수천 개의 토큰이 포함된 매우 긴 시퀀스에서는 여전히 정보 손실이 발생한다.

이러한 한계를 극복하기 위해 Attention(어텐션) 메커니즘이 도입되었으며, 이는 순환 구조를 완전히 제거하고 입력 시퀀스 전체를 한 번에 처리함으로써 학습 시간을 획기적으로 단축시킨 Transformer(트랜스포머) 구조로 이어졌다. 현재의 LLM(Large Language Model)들은 대부분 순환 구조 대신 트랜스포머 기반의 Self-Attention 구조를 채택하고 있다.

7.1 순환 구조 vs 트랜스포머 비교

비교 항목	순환 구조 (RNN/LSTM/GRU)	트랜스포머 (Transformer)
처리 방식	순차적 처리 (Sequential)	병렬적 처리 (Parallel)
데이터 관계	인접한 시점의 정보에 의존	모든 시점의 관계를 동시에 계산 (Attention)
학습 속도	느림 (시퀀스 길이에 비례)	빠름 (GPU 병렬 연산 최적화)
장기 기억	거리 멀어질수록 정보 손실 발생	거리에 상관없이 직접적인 참조 가능
주요 특징	상태(State)를 통한 기억 유지	위치 인코딩(Positional Encoding) 사용

📝 마크다운 원본

이 문서의 마크다운 원본 내용입니다.

# 순환 구조 (Recurrent Structure)

## 1. 개요
순환 구조(Recurrent Structure)란 신경망의 은닉층(Hidden Layer)에서 생성된 출력이 다시 자기 자신 혹은 이전 층의 입력으로 되돌아오는 연결 구조를 가진 신경망 형태를 의미한다.

일반적인 **피드포워드(Feed-forward) 신경망**은 입력층에서 출력층 방향으로 정보가 한 방향으로만 흐르며, 각 입력 데이터가 독립적으로 처리된다. 반면, 순환 구조는 내부의 루프(Loop)를 통해 과거의 정보를 기억하는 '상태(State)'를 유지함으로써, 데이터의 순서가 중요한 **순차적 데이터(Sequential Data)**를 처리하는 데 최적화되어 있다.

## 2. 동작 원리 및 구조
순환 구조의 핵심은 현재 시점($t$)의 출력값이 다음 시점($t+1$)의 입력값과 함께 연산에 사용된다는 점이다.

### 2.1 재귀적 메커니즘
시점 $t$에서의 은닉 상태 $h_t$는 다음과 같은 수식으로 정의된다.
$$h_t = \phi(W_h h_{t-1} + W_x x_t + b)$$
- $x_t$: 현재 시점의 입력 벡터
- $h_{t-1}$: 이전 시점의 은닉 상태 (과거의 기억)
- $W_h, W_x$: 가중치 행렬
- $\phi$: 활성화 함수. 기본 RNN에서는 $\tanh$가 표준적으로 사용된다. $\text{ReLU}$를 사용할 수도 있으나, 이 경우 값이 계속 누적되어 기울기 폭주(Exploding Gradient)가 발생할 위험이 있다.

### 2.2 시간축으로 펼치기 (Unrolling)
순환 구조는 개념적으로 루프 형태를 띠지만, 실제 연산과 학습을 위해 시간축으로 펼쳐서(Unrolling) 생각한다.

**[Unrolling 개념 다이어그램]**
```text
(Folded Form)             (Unrolled Form)
     ↺                        h_0    h_1    h_2    h_3
   [RNN]  --->  (Time)  ---> [RNN] -> [RNN] -> [RNN] -> [RNN]
     ↑                         ↑        ↑        ↑        ↑
     x_t                      x_0      x_1      x_2      x_3
```
이는 동일한 가중치를 공유하는 여러 개의 층이 시간 순서대로 나열된 구조와 동일하며, 이를 통해 시퀀스 데이터의 각 요소가 순차적으로 처리됨을 시각화할 수 있다.

## 3. BPTT (Backpropagation Through Time)
순환 신경망의 학습은 **BPTT(시간 기반 오차 역전파)** 알고리즘을 통해 이루어진다.

BPTT는 일반적인 역전파(Backpropagation)를 시간축으로 확장한 개념이다. 출력층에서 발생한 오차(Loss)를 현재 시점에서 시작하여 과거 시점으로 거슬러 올라가며 각 시점의 가중치를 업데이트한다. 이때 모든 시점에서 동일한 가중치 행렬($W$)을 공유하므로, 각 시점에서 계산된 기울기(Gradient)의 합을 통해 최종 가중치를 갱신한다. 다만, 이 과정에서 기울기가 너무 커지는 **기울기 폭주(Exploding Gradient)** 현상이 발생할 수 있으며, 이를 해결하기 위해 **Gradient Clipping** 기법이 사용된다.

## 4. 주요 모델 및 발전 과정

### 4.1 기본 RNN의 한계: Vanishing Gradient
기본 RNN은 시퀀스가 길어질수록 앞부분의 정보가 뒤로 전달되지 않는 **장기 의존성(Long-Term Dependency)** 문제에 직면한다. 이는 **기울기 소실(Vanishing Gradient)** 현상 때문이다.

**수학적 원리:**
BPTT 과정에서 $t$ 시점의 오차를 $k$ 시점 이전의 가중치로 미분할 때, 체인 룰(Chain Rule)에 의해 가중치 행렬 $W$의 거듭제곱 형태가 나타난다.
$$\frac{\partial L_t}{\partial W} \propto \prod_{i=k+1}^{t} \frac{\partial h_i}{\partial h_{i-1}}$$
만약 가중치 $W$의 고윳값(Eigenvalue)이 1보다 작다면, 시퀀스 길이가 길어질수록 기울기가 기하급수적으로 감소하여 0에 수렴하게 된다. 결과적으로 초기 입력 정보가 가중치 업데이트에 반영되지 않아 학습이 이루어지지 않는다.

### 4.2 LSTM과 GRU
이 문제를 해결하기 위해 '게이트(Gate)'라는 구조를 도입하여 정보의 흐름을 제어하는 모델들이 등장했다.

- **LSTM (Long Short-Term Memory):** 셀 상태(Cell State)를 도입하고 입력, 망각, 출력 게이트를 통해 어떤 정보를 유지하고 버릴지 결정한다.
- **GRU (Gated Recurrent Unit):** LSTM을 간소화한 모델로, 업데이트 게이트와 리셋 게이트만을 사용하여 연산 효율성을 높였다.

### 4.3 모델 특성 비교
*(기준: 동일한 hidden size 설정 시)*

| 구분 | RNN | LSTM | GRU |
| :--- | :--- | :--- | :--- |
| **구조** | 단순 루프 | 3개 게이트 + Cell State | 2개 게이트 |
| **장기 의존성** | 취약 (기울기 소실) | 강함 | 강함 |
| **연산 속도** | 매우 빠름 | 느림 | 보통 |
| **파라미터 수** | 적음 | 많음 | 중간 |

## 5. 주요 활용 분야 및 구조 분류

### 5.1 데이터 흐름에 따른 구조 분류
순환 구조는 입력과 출력의 개수에 따라 다음과 같이 분류된다.

| 구조 | 입력 $\rightarrow$ 출력 | 대표 사례 |
| :--- | :--- | :--- |
| **One-to-Many** | 단일 입력 $\rightarrow$ 시퀀스 출력 | 이미지 캡셔닝 (이미지 $\rightarrow$ 설명 문장) |
| **Many-to-One** | 시퀀스 입력 $\rightarrow$ 단일 출력 | 감성 분석 (문장 $\rightarrow$ 긍정/부정) |
| **Many-to-Many** | 시퀀스 입력 $\rightarrow$ 시퀀스 출력 | 기계 번역 (한국어 문장 $\rightarrow$ 영어 문장) |

### 5.2 실제 적용 사례
- **시계열 데이터 예측:** 주가 예측, 날씨 변화 분석, 전력 수요 예측.
- **자연어 처리(NLP):** 텍스트 생성, 챗봇, 문법 교정.
- **음성 인식:** 음성 신호(Waveform)를 텍스트로 변환.

## 6. 구현 예시 (PyTorch)
다음은 PyTorch를 사용하여 간단한 RNN 모델을 구축하고 검증하는 코드이다.

```python
import torch
import torch.nn as nn

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleRNN, self).__init__()
        self.hidden_size = hidden_size
        # RNN 레이어 정의: batch_first=True는 입력 텐서의 첫 번째 차원을 배치 크기로 설정함
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        # 최종 출력을 위한 선형 레이어
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # h0: 초기 은닉 상태 (batch_size, num_layers, hidden_size)로 0으로 초기화
        h0 = torch.zeros(1, x.size(0), self.hidden_size).to(x.device)
        
        # out: 모든 시점의 은닉 상태, hn: 마지막 시점의 은닉 상태
        out, hn = self.rnn(x, h0)
        
        # 마지막 시점의 출력값만 사용하여 결과 예측 (Many-to-One 구조)
        # out[:, -1, :] -> (batch_size, hidden_size)
        out = self.fc(out[:, -1, :])
        return out

# 1. 하이퍼파라미터 설정
input_size = 10  # 입력 벡터 차원 (feature)
hidden_size = 20 # 은닉 상태 차원
output_size = 1  # 출력 차원

# 2. 모델 인스턴스 생성
model = SimpleRNN(input_size, hidden_size, output_size)
print("--- Model Structure ---")
print(model)

# 3. 더미 입력 데이터를 통한 검증
# 입력 형태: (batch_size, sequence_length, input_size)
test_input = torch.randn(32, 5, 10) 
with torch.no_grad():
    output = model(test_input)

print("\n--- Test Result ---")
print(f"Input Shape: {test_input.shape}")   # [32, 5, 10]
print(f"Output Shape: {output.shape}")     # [32, 1]
```

## 7. 한계 및 최신 동향
순환 구조는 순차적 데이터 처리에 혁신을 가져왔으나, 다음과 같은 근본적인 한계가 존재한다.

1. **병렬 연산 불가:** $t$ 시점의 연산을 위해 $t-1$ 시점의 결과가 반드시 필요하므로, GPU를 활용한 대규모 병렬 처리가 어렵고 학습 속도가 느리다.
2. **완전한 장기 의존성 해결 불가:** LSTM/GRU가 개선을 이루었으나, 수천 개의 토큰이 포함된 매우 긴 시퀀스에서는 여전히 정보 손실이 발생한다.

이러한 한계를 극복하기 위해 **Attention(어텐션)** 메커니즘이 도입되었으며, 이는 순환 구조를 완전히 제거하고 입력 시퀀스 전체를 한 번에 처리함으로써 학습 시간을 획기적으로 단축시킨 **Transformer(트랜스포머)** 구조로 이어졌다. 현재의 LLM(Large Language Model)들은 대부분 순환 구조 대신 트랜스포머 기반의 Self-Attention 구조를 채택하고 있다.

### 7.1 순환 구조 vs 트랜스포머 비교

| 비교 항목 | 순환 구조 (RNN/LSTM/GRU) | 트랜스포머 (Transformer) |
| :--- | :--- | :--- |
| **처리 방식** | 순차적 처리 (Sequential) | 병렬적 처리 (Parallel) |
| **데이터 관계** | 인접한 시점의 정보에 의존 | 모든 시점의 관계를 동시에 계산 (Attention) |
| **학습 속도** | 느림 (시퀀스 길이에 비례) | 빠름 (GPU 병렬 연산 최적화) |
| **장기 기억** | 거리 멀어질수록 정보 손실 발생 | 거리에 상관없이 직접적인 참조 가능 |
| **주요 특징** | 상태(State)를 통한 기억 유지 | 위치 인코딩(Positional Encoding) 사용 |

AI 생성 콘텐츠 안내

이 문서는 AI 모델(gemma-4-31b)에 의해 생성된 콘텐츠입니다.

주의사항: AI가 생성한 내용은 부정확하거나 편향된 정보를 포함할 수 있습니다. 중요한 결정을 내리기 전에 반드시 신뢰할 수 있는 출처를 통해 정보를 확인하시기 바랍니다.

위키너와나